/**
 * 右键菜单管理器 - 图片视频下载器
 * 负责处理右键菜单的创建、管理和事件处理
 */

/**
 * 右键菜单管理器类
 */
export class ContextMenuManager {
    constructor() {
        this.menuItems = new Map();
        this.isInitialized = false;
    }

    /**
     * 初始化右键菜单管理器
     */
    async init() {
        if (this.isInitialized) return;

        console.log('初始化右键菜单管理器...');

        // 清除现有菜单
        await this.clearAllMenus();

        // 创建默认菜单
        await this.createDefaultMenus();

        this.isInitialized = true;
        console.log('右键菜单管理器初始化完成');
    }

    /**
     * 清除所有菜单
     */
    async clearAllMenus() {
        try {
            await chrome.contextMenus.removeAll();
            this.menuItems.clear();
            console.log('所有右键菜单已清除');
        } catch (error) {
            console.error('清除右键菜单失败:', error);
        }
    }

    /**
     * 创建默认菜单
     */
    async createDefaultMenus() {
        // 图片右键菜单
        await this.createMenu({
            id: 'downloadImage',
            title: '下载图片',
            contexts: ['image'],
            icons: {
                '16': '../icons/icon16.png',
                '32': '../icons/icon32.png'
            }
        });

        // 视频右键菜单
        await this.createMenu({
            id: 'downloadVideo',
            title: '下载视频',
            contexts: ['video'],
            icons: {
                '16': '../icons/icon16.png',
                '32': '../icons/icon32.png'
            }
        });

        // 页面右键菜单 - 下载所有图片
        await this.createMenu({
            id: 'downloadAllImages',
            title: '下载所有图片',
            contexts: ['page'],
            icons: {
                '16': '../icons/icon16.png',
                '32': '../icons/icon32.png'
            }
        });

        // 页面右键菜单 - 下载所有视频
        await this.createMenu({
            id: 'downloadAllVideos',
            title: '下载所有视频',
            contexts: ['page'],
            icons: {
                '16': '../icons/icon16.png',
                '32': '../icons/icon32.png'
            }
        });

        // 分隔符
        await this.createMenu({
            id: 'separator1',
            type: 'separator',
            contexts: ['page']
        });

        // 页面右键菜单 - 扫描媒体
        await this.createMenu({
            id: 'scanMedia',
            title: '扫描页面媒体',
            contexts: ['page'],
            icons: {
                '16': '../icons/icon16.png',
                '32': '../icons/icon32.png'
            }
        });

        // 页面右键菜单 - 打开下载器
        await this.createMenu({
            id: 'openDownloader',
            title: '打开下载器',
            contexts: ['page'],
            icons: {
                '16': '../icons/icon16.png',
                '32': '../icons/icon32.png'
            }
        });
    }

    /**
     * 创建菜单项
     */
    async createMenu(menuConfig) {
        try {
            const menuItem = {
                id: menuConfig.id,
                title: menuConfig.title,
                contexts: menuConfig.contexts || ['all'],
                documentUrlPatterns: menuConfig.documentUrlPatterns,
                targetUrlPatterns: menuConfig.targetUrlPatterns,
                enabled: menuConfig.enabled !== false,
                onclick: menuConfig.onclick
            };

            // 添加可选属性
            if (menuConfig.type) menuItem.type = menuConfig.type;
            if (menuConfig.icons) menuItem.icons = menuConfig.icons;
            if (menuConfig.parentId) menuItem.parentId = menuConfig.parentId;

            await chrome.contextMenus.create(menuItem);
            this.menuItems.set(menuConfig.id, menuConfig);

            console.log(`菜单项已创建: ${menuConfig.id}`);

        } catch (error) {
            console.error(`创建菜单项失败: ${menuConfig.id}`, error);
        }
    }

    /**
     * 更新菜单项
     */
    async updateMenu(menuId, updates) {
        try {
            const existingMenu = this.menuItems.get(menuId);
            if (!existingMenu) {
                throw new Error(`菜单项不存在: ${menuId}`);
            }

            // 删除现有菜单
            await chrome.contextMenus.remove(menuId);

            // 创建更新后的菜单
            const updatedMenu = { ...existingMenu, ...updates };
            await this.createMenu(updatedMenu);

            console.log(`菜单项已更新: ${menuId}`);

        } catch (error) {
            console.error(`更新菜单项失败: ${menuId}`, error);
        }
    }

    /**
     * 删除菜单项
     */
    async removeMenu(menuId) {
        try {
            await chrome.contextMenus.remove(menuId);
            this.menuItems.delete(menuId);

            console.log(`菜单项已删除: ${menuId}`);

        } catch (error) {
            console.error(`删除菜单项失败: ${menuId}`, error);
        }
    }

    /**
     * 启用/禁用菜单项
     */
    async setMenuEnabled(menuId, enabled) {
        try {
            await chrome.contextMenus.update(menuId, { enabled });

            const menu = this.menuItems.get(menuId);
            if (menu) {
                menu.enabled = enabled;
            }

            console.log(`菜单项状态已更新: ${menuId} - ${enabled ? '启用' : '禁用'}`);

        } catch (error) {
            console.error(`更新菜单项状态失败: ${menuId}`, error);
        }
    }

    /**
     * 更新菜单标题
     */
    async updateMenuTitle(menuId, title) {
        try {
            await chrome.contextMenus.update(menuId, { title });

            const menu = this.menuItems.get(menuId);
            if (menu) {
                menu.title = title;
            }

            console.log(`菜单项标题已更新: ${menuId} - ${title}`);

        } catch (error) {
            console.error(`更新菜单项标题失败: ${menuId}`, error);
        }
    }

    /**
     * 创建子菜单
     */
    async createSubMenu(parentId, subMenus) {
        try {
            for (const subMenu of subMenus) {
                await this.createMenu({
                    ...subMenu,
                    parentId: parentId
                });
            }

            console.log(`子菜单已创建: ${parentId}`);

        } catch (error) {
            console.error(`创建子菜单失败: ${parentId}`, error);
        }
    }

    /**
     * 创建动态菜单
     */
    async createDynamicMenu(menuConfig, dynamicItems) {
        try {
            // 创建父菜单
            await this.createMenu(menuConfig);

            // 创建动态子菜单
            for (const item of dynamicItems) {
                await this.createMenu({
                    id: `${menuConfig.id}_${item.id}`,
                    title: item.title,
                    parentId: menuConfig.id,
                    contexts: menuConfig.contexts,
                    onclick: item.onclick
                });
            }

            console.log(`动态菜单已创建: ${menuConfig.id}`);

        } catch (error) {
            console.error(`创建动态菜单失败: ${menuConfig.id}`, error);
        }
    }

    /**
     * 处理菜单点击事件
     */
    handleMenuClick(info, tab) {
        console.log('右键菜单点击:', info.menuItemId, info);

        switch (info.menuItemId) {
            case 'downloadImage':
                this.handleDownloadImage(info, tab);
                break;
            case 'downloadVideo':
                this.handleDownloadVideo(info, tab);
                break;
            case 'downloadAllImages':
                this.handleDownloadAllImages(tab);
                break;
            case 'downloadAllVideos':
                this.handleDownloadAllVideos(tab);
                break;
            case 'scanMedia':
                this.handleScanMedia(tab);
                break;
            case 'openDownloader':
                this.handleOpenDownloader(tab);
                break;
            default:
                // 处理动态菜单项
                this.handleDynamicMenuClick(info.menuItemId, info, tab);
        }
    }

    /**
     * 处理图片下载
     */
    async handleDownloadImage(info, tab) {
        try {
            const fileData = {
                id: `img_${Date.now()}`,
                url: info.srcUrl,
                filename: this.getFilenameFromUrl(info.srcUrl),
                type: 'image',
                title: info.title || '',
                alt: info.alt || ''
            };

            // 发送下载请求到后台脚本
            await chrome.runtime.sendMessage({
                action: 'downloadFiles',
                files: [fileData]
            });

            console.log('图片下载请求已发送');

        } catch (error) {
            console.error('处理图片下载失败:', error);
        }
    }

    /**
     * 处理视频下载
     */
    async handleDownloadVideo(info, tab) {
        try {
            const fileData = {
                id: `video_${Date.now()}`,
                url: info.srcUrl,
                filename: this.getFilenameFromUrl(info.srcUrl),
                type: 'video',
                title: info.title || ''
            };

            // 发送下载请求到后台脚本
            await chrome.runtime.sendMessage({
                action: 'downloadFiles',
                files: [fileData]
            });

            console.log('视频下载请求已发送');

        } catch (error) {
            console.error('处理视频下载失败:', error);
        }
    }

    /**
     * 处理下载所有图片
     */
    async handleDownloadAllImages(tab) {
        try {
            // 执行内容脚本扫描图片
            const result = await chrome.scripting.executeScript({
                target: { tabId: tab.id },
                function: this.scanPageImages
            });

            const images = result[0].result;

            if (images.length > 0) {
                // 发送下载请求到后台脚本
                await chrome.runtime.sendMessage({
                    action: 'downloadFiles',
                    files: images
                });

                console.log(`批量下载图片请求已发送: ${images.length} 张图片`);
            } else {
                console.log('页面中没有找到图片');
            }

        } catch (error) {
            console.error('处理批量下载图片失败:', error);
        }
    }

    /**
     * 处理下载所有视频
     */
    async handleDownloadAllVideos(tab) {
        try {
            // 执行内容脚本扫描视频
            const result = await chrome.scripting.executeScript({
                target: { tabId: tab.id },
                function: this.scanPageVideos
            });

            const videos = result[0].result;

            if (videos.length > 0) {
                // 发送下载请求到后台脚本
                await chrome.runtime.sendMessage({
                    action: 'downloadFiles',
                    files: videos
                });

                console.log(`批量下载视频请求已发送: ${videos.length} 个视频`);
            } else {
                console.log('页面中没有找到视频');
            }

        } catch (error) {
            console.error('处理批量下载视频失败:', error);
        }
    }

    /**
     * 处理扫描媒体
     */
    async handleScanMedia(tab) {
        try {
            // 发送扫描请求到后台脚本
            await chrome.runtime.sendMessage({
                action: 'scanMedia',
                tabId: tab.id
            });

            console.log('媒体扫描请求已发送');

        } catch (error) {
            console.error('处理扫描媒体失败:', error);
        }
    }

    /**
     * 处理打开下载器
     */
    async handleOpenDownloader(tab) {
        try {
            // 打开弹出窗口
            await chrome.action.openPopup();

            console.log('下载器已打开');

        } catch (error) {
            console.error('处理打开下载器失败:', error);
        }
    }

    /**
     * 处理动态菜单点击
     */
    handleDynamicMenuClick(menuItemId, info, tab) {
        // 这里可以处理动态创建的菜单项
        console.log('动态菜单点击:', menuItemId, info);
    }

    /**
     * 扫描页面图片（在内容脚本中执行）
     */
    scanPageImages() {
        const images = [];
        const imageElements = document.querySelectorAll('img[src]');

        imageElements.forEach((img, index) => {
            if (img.src && img.src.startsWith('http')) {
                images.push({
                    id: `img_${index}_${Date.now()}`,
                    url: img.src,
                    filename: this.getFilenameFromUrl(img.src),
                    type: 'image',
                    title: img.title || img.alt || '',
                    width: img.naturalWidth || img.width,
                    height: img.naturalHeight || img.height
                });
            }
        });

        return images;
    }

    /**
     * 扫描页面视频（在内容脚本中执行）
     */
    scanPageVideos() {
        const videos = [];
        const videoElements = document.querySelectorAll('video, iframe[src*="video"], iframe[src*="youtube"], iframe[src*="vimeo"]');

        videoElements.forEach((video, index) => {
            let src = video.src;

            if (video.tagName.toLowerCase() === 'video' && video.querySelector('source')) {
                src = video.querySelector('source').src;
            }

            if (src && src.startsWith('http')) {
                videos.push({
                    id: `video_${index}_${Date.now()}`,
                    url: src,
                    filename: this.getFilenameFromUrl(src),
                    type: 'video',
                    title: video.title || '',
                    width: video.videoWidth || video.width,
                    height: video.videoHeight || video.height
                });
            }
        });

        return videos;
    }

    /**
     * 从URL中提取文件名
     */
    getFilenameFromUrl(url) {
        try {
            const urlObj = new URL(url);
            const pathname = urlObj.pathname;
            const filename = pathname.split('/').pop();
            return filename || 'unknown';
        } catch (error) {
            return 'unknown';
        }
    }

    /**
     * 根据网站创建特定菜单
     */
    async createSiteSpecificMenus(domain) {
        const siteMenus = {
            'youtube.com': [
                {
                    id: 'downloadYoutubeVideo',
                    title: '下载YouTube视频',
                    contexts: ['page'],
                    onclick: (info, tab) => this.handleYoutubeDownload(tab)
                }
            ],
            'bilibili.com': [
                {
                    id: 'downloadBilibiliVideo',
                    title: '下载B站视频',
                    contexts: ['page'],
                    onclick: (info, tab) => this.handleBilibiliDownload(tab)
                }
            ]
        };

        const menus = siteMenus[domain];
        if (menus) {
            for (const menu of menus) {
                await this.createMenu(menu);
            }
            console.log(`网站特定菜单已创建: ${domain}`);
        }
    }

    /**
     * 处理YouTube下载
     */
    async handleYoutubeDownload(tab) {
        try {
            // 这里可以添加YouTube特定的下载逻辑
            console.log('YouTube下载功能待实现');

            // 显示提示
            await chrome.scripting.executeScript({
                target: { tabId: tab.id },
                function: () => {
                    alert('YouTube下载功能正在开发中...');
                }
            });

        } catch (error) {
            console.error('处理YouTube下载失败:', error);
        }
    }

    /**
     * 处理B站下载
     */
    async handleBilibiliDownload(tab) {
        try {
            // 这里可以添加B站特定的下载逻辑
            console.log('B站下载功能待实现');

            // 显示提示
            await chrome.scripting.executeScript({
                target: { tabId: tab.id },
                function: () => {
                    alert('B站下载功能正在开发中...');
                }
            });

        } catch (error) {
            console.error('处理B站下载失败:', error);
        }
    }

    /**
     * 获取所有菜单项
     */
    getAllMenus() {
        return Array.from(this.menuItems.values());
    }

    /**
     * 检查菜单项是否存在
     */
    hasMenu(menuId) {
        return this.menuItems.has(menuId);
    }

    /**
     * 销毁右键菜单管理器
     */
    async destroy() {
        try {
            await this.clearAllMenus();
            this.menuItems.clear();
            this.isInitialized = false;
            console.log('右键菜单管理器已销毁');
        } catch (error) {
            console.error('销毁右键菜单管理器失败:', error);
        }
    }
} 